home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / amiga / mpeg / mpgplyr1.lha / src / util.h < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-09  |  18.9 KB  |  329 lines
  1. /*
  2.  * Copyright (c) 1992 The Regents of the University of California.
  3.  * All rights reserved.
  4.  * 
  5.  * Permission to use, copy, modify, and distribute this software and its
  6.  * documentation for any purpose, without fee, and without written agreement is
  7.  * hereby granted, provided that the above copyright notice and the following
  8.  * two paragraphs appear in all copies of this software.
  9.  * 
  10.  * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
  11.  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  12.  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
  13.  * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  * 
  15.  * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  16.  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  17.  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  18.  * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
  19.  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  20.  */
  21.  
  22. /* Status codes for bit stream i/o operations. */
  23.  
  24. #define NO_VID_STREAM -1
  25. #define UNDERFLOW -2
  26. #define OK 1
  27.  
  28. /* Size increment of extension data buffers. */
  29.  
  30. #define EXT_BUF_SIZE 1024
  31.  
  32. /* External declarations for bitstream i/o operations. */
  33. extern unsigned int bitMask[];
  34. extern unsigned int nBitMask[];
  35. extern unsigned int rBitMask[];
  36. extern unsigned int bitTest[];
  37. extern int next_bits();
  38. extern char *get_ext_data();
  39. extern int next_start_code();
  40. extern char *get_extra_bit_info();
  41.  
  42. /* External declarations of bitstream global variables. */
  43. extern unsigned int curBits;
  44. extern int bitOffset;
  45. extern int bufLength;
  46. extern unsigned int *bitBuffer;
  47.  
  48. /* Macro for updating bit counter if analysis tool is on. */
  49. #ifdef ANALYSIS
  50. #define UPDATE_COUNT(numbits) bitCount += numbits
  51. #else
  52. #define UPDATE_COUNT(numbits)
  53. #endif
  54.  
  55. #ifdef NO_SANITY_CHECKS
  56. #define get_bits1(result)                                                 \
  57. {                                                                         \
  58.   UPDATE_COUNT(1);                                                        \
  59.   if (bitOffset < 31) {                                                   \
  60.     *(result) = ((curBits & bitTest[bitOffset]) != 0);                    \
  61.     bitOffset++;                                                          \
  62.   }                                                                       \
  63.   else {                                                                  \
  64.     *(result) = (curBits & 0x00000001);                                   \
  65.     bitOffset = 0;                                                        \
  66.     bitBuffer++;                                                          \
  67.     curBits = *bitBuffer;                                                 \
  68.     bufLength--;                                                          \
  69.   }                                                                       \
  70. }
  71.  
  72. #define get_bits2(result)                                                 \
  73. {                                                                         \
  74.   UPDATE_COUNT(2)                                                         \
  75.   if (bitOffset < 30) {                                                   \
  76.     *(result) = ((curBits & bitMask[bitOffset]) >>                        \
  77.            (30-bitOffset));                                           \
  78.     bitOffset += 2;                                                       \
  79.   }                                                                       \
  80.   else if (bitOffset == 30) {                                             \
  81.     *(result) = (curBits & 0x00000003);                                   \
  82.     bitOffset = 0;                                                        \
  83.     bitBuffer++;                                                          \
  84.     curBits = *bitBuffer;                                                 \
  85.     bufLength--;                                                          \
  86.   }                                                                       \
  87.   else {                                                                  \
  88.     *(result) = (((curBits & 0x01) << 1) |                                \
  89.            ((*(bitBuffer+1) & 0x80000000) != 0));                     \
  90.     bitOffset = 1;                                                        \
  91.     bitBuffer++;                                                          \
  92.     curBits = *bitBuffer;                                                 \
  93.     bufLength--;                                                          \
  94.   }                                                                       \
  95. }
  96.  
  97. #define get_bitsX(num, thresh, result)                                    \
  98. {                                                                         \
  99.   int OFFnum = (bitOffset - thresh);                                      \
  100.                                                                           \
  101.   UPDATE_COUNT(num);                                                      \
  102.                                                                           \
  103.   if (OFFnum < 0) {                                                       \
  104.     *(result) = ((curBits & bitMask[bitOffset]) >> (-OFFnum));            \
  105.     bitOffset += num;                                                     \
  106.   } else if (OFFnum == 0) {                                               \
  107.     *(result) = (curBits & bitMask[bitOffset]) << OFFnum;                 \
  108.     bitBuffer++;                                                          \
  109.     curBits = *bitBuffer;                                                 \
  110.     bufLength--;                                                          \
  111.     bitOffset = 0;                                                        \
  112.   } else {                                                                \
  113.     *(result) = (((curBits & bitMask[bitOffset]) << OFFnum) |             \
  114.              ((*(bitBuffer+1) & (nBitMask[OFFnum])) >> (32-OFFnum))); \
  115.     bitBuffer++;                                                          \
  116.     curBits = *bitBuffer;                                                 \
  117.     bufLength--;                                                          \
  118.     bitOffset = OFFnum;                                                   \
  119.   }                                                                       \
  120. }
  121. #else
  122.  
  123. #define get_bits1(result)                                                 \
  124. {                                                                         \
  125.                                                                           \
  126.   /* Check for underflow. */                                              \
  127.                                                                           \
  128.   if (bufLength < 2) {                                                    \
  129.     correct_underflow();                                                  \
  130.   }                                                                       \
  131.   UPDATE_COUNT(1);                                                      \
  132.                                                                           \
  133.   if (bitOffset < 31) {                                                   \
  134.     *(result) = ((curBits & bitTest[bitOffset]) != 0);                    \
  135.     bitOffset++;                                                          \
  136.   }                                                                       \
  137.   else {                                                                  \
  138.     *(result) = (curBits & 0x00000001);                                   \
  139.     bitOffset = 0;                                                        \
  140.     bitBuffer++;                                                          \
  141.     curBits = *bitBuffer;                                                 \
  142.     bufLength--;                                                          \
  143.   }                                                                       \
  144. }
  145.  
  146. #define get_bits2(result)                                                 \
  147. {                                                                         \
  148.                                                                           \
  149.   /* Check for underflow. */                                              \
  150.                                                                           \
  151.   if (bufLength < 2) {                                                    \
  152.     correct_underflow();                                                  \
  153.   }                                                                       \
  154.   UPDATE_COUNT(2);                                                      \
  155.                                                                           \
  156.   if (bitOffset < 30) {                                                   \
  157.     *(result) = ((curBits & bitMask[bitOffset]) >>                        \
  158.            (30-bitOffset));                                           \
  159.     bitOffset += 2;                                                       \
  160.   }                                                                       \
  161.   else if (bitOffset == 30) {                                             \
  162.     *(result) = (curBits & 0x00000003);                                   \
  163.     bitOffset = 0;                                                        \
  164.     bitBuffer++;                                                          \
  165.     curBits = *bitBuffer;                                                 \
  166.     bufLength--;                                                          \
  167.   }                                                                       \
  168.   else {                                                                  \
  169.     *(result) = (((curBits & 0x01) << 1) |                                \
  170.            ((*(bitBuffer+1) & 0x80000000) != 0));                     \
  171.     bitOffset = 1;                                                        \
  172.     bitBuffer++;                                                          \
  173.     curBits = *bitBuffer;                                                 \
  174.     bufLength--;                                                          \
  175.   }                                                                       \
  176. }
  177.  
  178. #define get_bitsX(num, thresh, result)                                    \
  179. {                                                                         \
  180.   int OFFnum = (bitOffset - thresh);                                      \
  181.                                                                           \
  182.   /* Check for underflow. */                                              \
  183.                                                                           \
  184.   if (bufLength < 2) {                                                    \
  185.     correct_underflow();                                                  \
  186.   }                                                                       \
  187.   UPDATE_COUNT(num);                                                      \
  188.                                                                           \
  189.   if (OFFnum < 0) {                                                       \
  190.     *(result) = ((curBits & bitMask[bitOffset]) >> (-OFFnum));            \
  191.     bitOffset += num;                                                     \
  192.   } else if (OFFnum == 0) {                                               \
  193.     *(result) = (curBits & bitMask[bitOffset]) << OFFnum;                 \
  194.     bitBuffer++;                                                          \
  195.     curBits = *bitBuffer;                                                 \
  196.     bufLength--;                                                          \
  197.     bitOffset = 0;                                                        \
  198.   } else {                                                                \
  199.     *(result) = (((curBits & bitMask[bitOffset]) << OFFnum) |             \
  200.              ((*(bitBuffer+1) & (nBitMask[OFFnum])) >> (32-OFFnum))); \
  201.     bitBuffer++;                                                          \
  202.     curBits = *bitBuffer;                                                 \
  203.     bufLength--;                                                          \
  204.     bitOffset = OFFnum;                                                   \
  205.   }                                                                       \
  206. }
  207. #endif
  208.  
  209. #define get_bits3(result) get_bitsX(3, 29, result)
  210. #define get_bits4(result) get_bitsX(4, 28, result)
  211. #define get_bits5(result) get_bitsX(5, 27, result)
  212. #define get_bits6(result) get_bitsX(6, 26, result)
  213. #define get_bits7(result) get_bitsX(7, 25, result)
  214. #define get_bits8(result) get_bitsX(8, 24, result)
  215. #define get_bits9(result) get_bitsX(9, 23, result)
  216. #define get_bits10(result) get_bitsX(10, 22, result)
  217. #define get_bits11(result) get_bitsX(11, 21, result)
  218. #define get_bits12(result) get_bitsX(12, 20, result)
  219. #define get_bits16(result) get_bitsX(16, 16, result)
  220. #define get_bits18(result) get_bitsX(18, 14, result)
  221. #define get_bits32(result) get_bitsX(32, 0, result)
  222.  
  223. #define get_bitsn(num, result) get_bitsX((num),(32-(num)),result)
  224.  
  225. #ifdef NO_SANITY_CHECKS
  226. #define show_bitsX(num, thresh, result)                                    \
  227. {                                                                          \
  228.   int OFFnum = (bitOffset - thresh);                                       \
  229.                                                                           \
  230.   if (OFFnum <= 0) {                                                        \
  231.     *(result) = ((curBits & bitMask[bitOffset]) >> (-OFFnum));             \
  232.   } else {                                                                 \
  233.     *(result) = (((curBits & bitMask[bitOffset]) << OFFnum) |              \
  234.              ((*(bitBuffer+1) & (nBitMask[OFFnum])) >> (32-OFFnum)));  \
  235.   }                                                                        \
  236. }
  237. #else
  238. #define show_bitsX(num, thresh, result)                                    \
  239. {                                                                          \
  240.   int OFFnum = (bitOffset - thresh);                                       \
  241.                                                                            \
  242.   /* Check for underflow. */                                               \
  243.   if (bufLength < 2) {                                                     \
  244.     correct_underflow();                                                   \
  245.   }                                                                        \
  246.                                                                            \
  247.   if (OFFnum <= 0) {                                                        \
  248.     *(result) = ((curBits & bitMask[bitOffset]) >> (-OFFnum));             \
  249.   } else {                                                                 \
  250.     *(result) = (((curBits & bitMask[bitOffset]) << OFFnum) |              \
  251.              ((*(bitBuffer+1) & (nBitMask[OFFnum])) >> (32-OFFnum)));  \
  252.   }                                                                        \
  253. }
  254. #endif
  255.  
  256. #define show_bits1(result)  show_bitsX(1,  31, result)
  257. #define show_bits2(result)  show_bitsX(2,  30, result)
  258. #define show_bits3(result)  show_bitsX(3,  29, result)
  259. #define show_bits4(result)  show_bitsX(4,  28, result)
  260. #define show_bits5(result)  show_bitsX(5,  27, result)
  261. #define show_bits6(result)  show_bitsX(6,  26, result)
  262. #define show_bits7(result)  show_bitsX(7,  25, result)
  263. #define show_bits8(result)  show_bitsX(8,  24, result)
  264. #define show_bits9(result)  show_bitsX(9,  23, result)
  265. #define show_bits10(result) show_bitsX(10, 22, result)
  266. #define show_bits11(result) show_bitsX(11, 21, result)
  267. #define show_bits12(result) show_bitsX(12, 20, result)
  268. #define show_bits13(result) show_bitsX(13, 19, result)
  269. #define show_bits14(result) show_bitsX(14, 18, result)
  270. #define show_bits15(result) show_bitsX(15, 17, result)
  271. #define show_bits16(result) show_bitsX(16, 16, result)
  272. #define show_bits17(result) show_bitsX(17, 15, result)
  273. #define show_bits18(result) show_bitsX(18, 14, result)
  274. #define show_bits19(result) show_bitsX(19, 13, result)
  275. #define show_bits20(result) show_bitsX(20, 12, result)
  276. #define show_bits21(result) show_bitsX(21, 11, result)
  277. #define show_bits22(result) show_bitsX(22, 10, result)
  278. #define show_bits23(result) show_bitsX(23,  9, result)
  279. #define show_bits24(result) show_bitsX(24,  8, result)
  280. #define show_bits25(result) show_bitsX(25,  7, result)
  281. #define show_bits26(result) show_bitsX(26,  6, result)
  282. #define show_bits27(result) show_bitsX(27,  5, result)
  283. #define show_bits28(result) show_bitsX(28,  4, result)
  284. #define show_bits29(result) show_bitsX(29,  3, result)
  285. #define show_bits30(result) show_bitsX(30,  2, result)
  286. #define show_bits31(result) show_bitsX(31,  1, result)
  287. #define show_bits32(result) show_bitsX(32,  0, result)
  288.  
  289. #define show_bitsn(num,result) show_bitsX((num),(32-(num)),result)
  290.  
  291. #ifdef NO_SANITY_CHECKS
  292. #define flush_bits(num)                                               \
  293. {                                                                     \
  294.   bitOffset += num;                                                   \
  295.                                                                       \
  296.   UPDATE_COUNT(num);                                                      \
  297.                                                                           \
  298.   if (bitOffset > 31) {                                               \
  299.     bitBuffer++;                                                      \
  300.     curBits = *bitBuffer;                                             \
  301.     bufLength--;                                                      \
  302.     bitOffset -= 32;                                                  \
  303.   }                                                                   \
  304. }
  305. #else
  306. #define flush_bits(num)                                               \
  307. {                                                                     \
  308.   if (curVidStream == NULL) {                                         \
  309.     /* Deal with no vid stream here. */                               \
  310.   }                                                                   \
  311.                                                                       \
  312.   if (bufLength < 2) {                                                \
  313.     correct_underflow();                                              \
  314.   }                                                                   \
  315.                                                                       \
  316.   UPDATE_COUNT(num);                                                      \
  317.                                                                           \
  318.   bitOffset += num;                                                   \
  319.                                                                       \
  320.   if (bitOffset > 31) {                                               \
  321.     bitBuffer++;                                                      \
  322.     curBits = *bitBuffer;                                             \
  323.     bufLength--;                                                      \
  324.     bitOffset -= 32;                                                  \
  325.   }                                                                   \
  326. }
  327. #endif
  328.  
  329.